home *** CD-ROM | disk | FTP | other *** search
/ Action Games (2008) / akcnihry1.iso / Code RED / codered.exe / Data1.cab / g_spawn.c1 < prev    next >
Encoding:
Text File  |  2002-12-07  |  23.0 KB  |  954 lines
  1.  
  2. #include "g_local.h"
  3.  
  4. typedef struct
  5. {
  6.     char    *name;
  7.     void    (*spawn)(edict_t *ent);
  8. } spawn_t;
  9.  
  10.  
  11. void SP_item_health (edict_t *self);
  12. void SP_item_health_small (edict_t *self);
  13. void SP_item_health_large (edict_t *self);
  14. void SP_item_health_mega (edict_t *self);
  15.  
  16. void SP_info_player_start (edict_t *ent);
  17. void SP_info_player_deathmatch (edict_t *ent);
  18. void SP_info_player_coop (edict_t *ent);
  19. void SP_info_player_intermission (edict_t *ent);
  20.  
  21. void SP_func_plat (edict_t *ent);
  22. void SP_func_rotating (edict_t *ent);
  23. void SP_func_button (edict_t *ent);
  24. void SP_func_door (edict_t *ent);
  25. void SP_func_door_secret (edict_t *ent);
  26. void SP_func_door_rotating (edict_t *ent);
  27. void SP_func_water (edict_t *ent);
  28. void SP_func_train (edict_t *ent);
  29. void SP_func_conveyor (edict_t *self);
  30. void SP_func_wall (edict_t *self);
  31. void SP_func_object (edict_t *self);
  32. void SP_func_explosive (edict_t *self);
  33. void SP_func_timer (edict_t *self);
  34. void SP_func_areaportal (edict_t *ent);
  35. void SP_func_clock (edict_t *ent);
  36. void SP_func_killbox (edict_t *ent);
  37.  
  38. void SP_trigger_always (edict_t *ent);
  39. void SP_trigger_once (edict_t *ent);
  40. void SP_trigger_multiple (edict_t *ent);
  41. void SP_trigger_relay (edict_t *ent);
  42. void SP_trigger_push (edict_t *ent);
  43. void SP_trigger_hurt (edict_t *ent);
  44. void SP_trigger_key (edict_t *ent);
  45. void SP_trigger_counter (edict_t *ent);
  46. void SP_trigger_elevator (edict_t *ent);
  47. void SP_trigger_gravity (edict_t *ent);
  48. void SP_trigger_monsterjump (edict_t *ent);
  49.  
  50. void SP_target_temp_entity (edict_t *ent);
  51. void SP_target_speaker (edict_t *ent);
  52. void SP_target_explosion (edict_t *ent);
  53. void SP_target_changelevel (edict_t *ent);
  54. void SP_target_secret (edict_t *ent);
  55. void SP_target_goal (edict_t *ent);
  56. void SP_target_splash (edict_t *ent);
  57. void SP_target_steam (edict_t *ent);
  58. void SP_target_spawner (edict_t *ent);
  59. void SP_target_blaster (edict_t *ent);
  60. void SP_target_crosslevel_trigger (edict_t *ent);
  61. void SP_target_crosslevel_target (edict_t *ent);
  62. void SP_target_laser (edict_t *self);
  63. void SP_target_help (edict_t *ent);
  64. void SP_target_actor (edict_t *ent);
  65. void SP_target_lightramp (edict_t *self);
  66. void SP_target_earthquake (edict_t *ent);
  67. void SP_target_character (edict_t *ent);
  68. void SP_target_string (edict_t *ent);
  69. void SP_target_fire (edict_t *ent);
  70.  
  71. void SP_worldspawn (edict_t *ent);
  72. void SP_viewthing (edict_t *ent);
  73.  
  74. void SP_light (edict_t *self);
  75. void SP_light_mine1 (edict_t *ent);
  76. void SP_light_mine2 (edict_t *ent);
  77. void SP_info_null (edict_t *self);
  78. void SP_info_notnull (edict_t *self);
  79. void SP_path_corner (edict_t *self);
  80. void SP_point_combat (edict_t *self);
  81.  
  82. void SP_misc_explobox (edict_t *self);
  83. void SP_misc_banner (edict_t *self);
  84.  
  85. void SP_misc_satellite_dish (edict_t *self);
  86. void SP_misc_actor (edict_t *self);
  87. void SP_misc_gib_arm (edict_t *self);
  88. void SP_misc_gib_leg (edict_t *self);
  89. void SP_misc_gib_head (edict_t *self);
  90. void SP_misc_insane (edict_t *self);
  91. void SP_misc_deadsoldier (edict_t *self);
  92. void SP_misc_viper (edict_t *self);
  93. void SP_misc_viper_bomb (edict_t *self);
  94. void SP_misc_bigviper (edict_t *self);
  95. void SP_misc_leader_ship (edict_t *self);
  96. void SP_misc_teleporter (edict_t *self);
  97. void SP_misc_teleporter_dest (edict_t *self);
  98. void SP_misc_blackhole (edict_t *self);
  99. void SP_misc_eastertank (edict_t *self);
  100. void SP_misc_easterchick (edict_t *self);
  101. void SP_misc_easterchick2 (edict_t *self);
  102.  
  103. void SP_misc_skele (edict_t *self);
  104. void SP_misc_skele_sit (edict_t *self);
  105. void SP_misc_skele_lie (edict_t *self);
  106. void SP_misc_skele_blood (edict_t *self);
  107. void SP_misc_vortex (edict_t *self);
  108. void SP_misc_grass (edict_t *self);
  109. void SP_misc_tube (edict_t *self);
  110. void SP_misc_patient (edict_t *self);
  111. void SP_misc_head (edict_t *self);
  112.  
  113. void SP_monster_martian (edict_t *self);
  114. void SP_monster_martian_naked (edict_t *self);
  115. void SP_monster_bigray (edict_t *self);
  116. void SP_monster_ambass (edict_t *self);
  117. void SP_monster_emporer (edict_t *self);
  118. void SP_monster_warmach (edict_t *self);
  119. void SP_monster_saucer (edict_t *self);
  120. void SP_monster_bigmech (edict_t *self);
  121. void SP_monster_smallmech (edict_t *self);
  122.  
  123. void SP_npc_astronaut (edict_t *self);
  124. void SP_npc_soldier (edict_t *self);
  125. void SP_npc_commander (edict_t *self);
  126. void SP_npc_soldier_standing (edict_t *self);
  127. void SP_npc_soldier_hostile (edict_t *self);
  128. void SP_npc_droid (edict_t *self);
  129. void SP_npc_alien (edict_t *self);
  130. void SP_npc_surgeon (edict_t *self);
  131. void SP_npc_redneck (edict_t *self);
  132.  
  133. spawn_t    spawns[] = {
  134.     {"item_health", SP_item_health},
  135.     {"item_health_small", SP_item_health_small},
  136.     {"item_health_large", SP_item_health_large},
  137.     {"item_health_mega", SP_item_health_mega},
  138.  
  139.     {"info_player_start", SP_info_player_start},
  140.     {"info_player_deathmatch", SP_info_player_deathmatch},
  141.     {"info_player_coop", SP_info_player_coop},
  142.     {"info_player_intermission", SP_info_player_intermission},
  143.  
  144.     {"func_plat", SP_func_plat},
  145.     {"func_button", SP_func_button},
  146.     {"func_door", SP_func_door},
  147.     {"func_door_secret", SP_func_door_secret},
  148.     {"func_door_rotating", SP_func_door_rotating},
  149.     {"func_rotating", SP_func_rotating},
  150.     {"func_train", SP_func_train},
  151.     {"func_water", SP_func_water},
  152.     {"func_conveyor", SP_func_conveyor},
  153.     {"func_areaportal", SP_func_areaportal},
  154.     {"func_clock", SP_func_clock},
  155.     {"func_wall", SP_func_wall},
  156.     {"func_object", SP_func_object},
  157.     {"func_timer", SP_func_timer},
  158.     {"func_explosive", SP_func_explosive},
  159.     {"func_killbox", SP_func_killbox},
  160.  
  161.     {"trigger_always", SP_trigger_always},
  162.     {"trigger_once", SP_trigger_once},
  163.     {"trigger_multiple", SP_trigger_multiple},
  164.     {"trigger_relay", SP_trigger_relay},
  165.     {"trigger_push", SP_trigger_push},
  166.     {"trigger_hurt", SP_trigger_hurt},
  167.     {"trigger_key", SP_trigger_key},
  168.     {"trigger_counter", SP_trigger_counter},
  169.     {"trigger_elevator", SP_trigger_elevator},
  170.     {"trigger_gravity", SP_trigger_gravity},
  171.     {"trigger_monsterjump", SP_trigger_monsterjump},
  172.  
  173.     {"target_temp_entity", SP_target_temp_entity},
  174.     {"target_speaker", SP_target_speaker},
  175.     {"target_explosion", SP_target_explosion},
  176.     {"target_changelevel", SP_target_changelevel},
  177.     {"target_secret", SP_target_secret},
  178.     {"target_goal", SP_target_goal},
  179.     {"target_splash", SP_target_splash},
  180.     {"target_steam", SP_target_steam},  
  181.     {"target_spawner", SP_target_spawner},
  182.     {"target_blaster", SP_target_blaster},
  183.     {"target_crosslevel_trigger", SP_target_crosslevel_trigger},
  184.     {"target_crosslevel_target", SP_target_crosslevel_target},
  185.     {"target_laser", SP_target_laser},
  186.     {"target_help", SP_target_help},
  187.     {"target_actor", SP_target_actor},
  188.     {"target_lightramp", SP_target_lightramp},
  189.     {"target_earthquake", SP_target_earthquake},
  190.     {"target_character", SP_target_character},
  191.     {"target_string", SP_target_string},
  192.     {"target_fire", SP_target_fire},
  193.  
  194.     {"worldspawn", SP_worldspawn},
  195.     {"viewthing", SP_viewthing},
  196.  
  197.     {"light", SP_light},
  198.     {"light_mine1", SP_light_mine1},
  199.     {"light_mine2", SP_light_mine2},
  200.     {"info_null", SP_info_null},
  201.     {"func_group", SP_info_null},
  202.     {"info_notnull", SP_info_notnull},
  203.     {"path_corner", SP_path_corner},
  204.     {"point_combat", SP_point_combat},
  205.  
  206.     {"misc_explobox", SP_misc_explobox},
  207.     {"misc_banner", SP_misc_banner},
  208.  
  209.     {"misc_satellite_dish", SP_misc_satellite_dish},
  210.     {"misc_actor", SP_misc_actor},
  211.     {"misc_gib_arm", SP_misc_gib_arm},
  212.     {"misc_gib_leg", SP_misc_gib_leg}, 
  213.     {"misc_gib_head", SP_misc_gib_head},
  214.     {"misc_insane", SP_misc_insane},
  215.     {"misc_deadsoldier", SP_misc_deadsoldier},
  216.     {"misc_viper", SP_misc_viper},
  217.     {"misc_viper_bomb", SP_misc_viper_bomb},
  218.     {"misc_bigviper", SP_misc_bigviper},
  219.     {"misc_strogg_ship", SP_misc_leader_ship},
  220.     {"misc_teleporter", SP_misc_teleporter},
  221.     {"misc_teleporter_dest", SP_misc_teleporter_dest},
  222.     {"misc_blackhole", SP_misc_blackhole},
  223.     {"misc_eastertank", SP_misc_eastertank},
  224.     {"misc_easterchick", SP_misc_easterchick},
  225.     {"misc_easterchick2", SP_misc_easterchick2},
  226.  
  227.     {"misc_skele", SP_misc_skele},
  228.     {"misc_skele_sit", SP_misc_skele_sit},
  229.     {"misc_skele_lie", SP_misc_skele_lie},
  230.     {"misc_skele_blood", SP_misc_skele_blood},
  231.     {"misc_vortex", SP_misc_vortex},
  232.     {"misc_grass", SP_misc_grass},
  233.     {"misc_tube", SP_misc_tube},
  234.     {"misc_patient", SP_misc_patient},
  235.     {"misc_head", SP_misc_head},
  236.  
  237.     {"monster_martian", SP_monster_martian},
  238.     {"monster_martian_naked", SP_monster_martian_naked},
  239.     {"monster_bigray", SP_monster_bigray},
  240.     {"monster_ambass", SP_monster_ambass},
  241.     {"monster_emporer", SP_monster_emporer},
  242.     {"monster_saucer", SP_monster_saucer},
  243.     {"monster_warmach", SP_monster_warmach},
  244.     {"monster_bigmech", SP_monster_bigmech},
  245.     {"monster_smallmech", SP_monster_smallmech},
  246.  
  247.     {"npc_astronaut", SP_npc_astronaut},
  248.     {"npc_soldier", SP_npc_soldier},
  249.     {"npc_commander", SP_npc_commander},
  250.     {"npc_soldier_standing", SP_npc_soldier_standing},
  251.     {"npc_soldier_hostile", SP_npc_soldier_hostile},
  252.     {"npc_droid", SP_npc_droid},
  253.     {"npc_alien", SP_npc_alien},
  254.     {"npc_surgeon", SP_npc_surgeon},
  255.     {"npc_redneck", SP_npc_redneck},
  256.  
  257.     {NULL, NULL}
  258. };
  259.  
  260. /*
  261. ===============
  262. ED_CallSpawn
  263.  
  264. Finds the spawn function for the entity and calls it
  265. ===============
  266. */
  267. void ED_CallSpawn (edict_t *ent)
  268. {
  269.     spawn_t    *s;
  270.     gitem_t    *item;
  271.     int        i;
  272.  
  273.     if (!ent->classname)
  274.     {
  275.         gi.dprintf ("ED_CallSpawn: NULL classname\n");
  276.         return;
  277.     }
  278.  
  279.     // check item spawn functions
  280.     for (i=0,item=itemlist ; i<game.num_items ; i++,item++)
  281.     {
  282.         if (!item->classname)
  283.             continue;
  284.         if (!strcmp(item->classname, ent->classname))
  285.         {    // found it
  286.             SpawnItem (ent, item);
  287.             return;
  288.         }
  289.     }
  290.  
  291.     //make a teleporting effect here for martians
  292. //    if (!Q_stricmp(ent->classname, "monster_martian")) || !Q_stricmp(ent->classname == "monster_ambass"))
  293. //    {
  294.         gi.WriteByte (svc_temp_entity);
  295.         gi.WriteByte (TE_BOSSTPORT);//for now
  296.         gi.WritePosition (ent->s.origin);
  297.         gi.multicast (ent->s.origin, MULTICAST_PVS);
  298. //    }
  299.  
  300.     // check normal spawn functions
  301.     for (s=spawns ; s->name ; s++)
  302.     {
  303.         if (!strcmp(s->name, ent->classname))
  304.         {    // found it
  305.             s->spawn (ent);
  306.             return;
  307.         }
  308.     }
  309.  
  310.     gi.dprintf ("%s doesn't have a spawn function\n", ent->classname);
  311. }
  312.  
  313. /*
  314. =============
  315. ED_NewString
  316. =============
  317. */
  318. char *ED_NewString (char *string)
  319. {
  320.     char    *newb, *new_p;
  321.     int        i,l;
  322.     
  323.     l = strlen(string) + 1;
  324.  
  325.     newb = gi.TagMalloc (l, TAG_LEVEL);
  326.  
  327.     new_p = newb;
  328.  
  329.     for (i=0 ; i< l ; i++)
  330.     {
  331.         if (string[i] == '\\' && i < l-1)
  332.         {
  333.             i++;
  334.             if (string[i] == 'n')
  335.                 *new_p++ = '\n';
  336.             else
  337.                 *new_p++ = '\\';
  338.         }
  339.         else
  340.             *new_p++ = string[i];
  341.     }
  342.     
  343.     return newb;
  344. }
  345.  
  346.  
  347.  
  348.  
  349. /*
  350. ===============
  351. ED_ParseField
  352.  
  353. Takes a key/value pair and sets the binary values
  354. in an edict
  355. ===============
  356. */
  357. void ED_ParseField (char *key, char *value, edict_t *ent)
  358. {
  359.     field_t    *f;
  360.     byte    *b;
  361.     float    v;
  362.     vec3_t    vec;
  363.  
  364.     for (f=fields ; f->name ; f++)
  365.     {
  366.         if (!Q_stricmp(f->name, key))
  367.         {    // found it
  368.             if (f->flags & FFL_SPAWNTEMP)
  369.                 b = (byte *)&st;
  370.             else
  371.                 b = (byte *)ent;
  372.  
  373.             switch (f->type)
  374.             {
  375.             case F_LSTRING:
  376.                 *(char **)(b+f->ofs) = ED_NewString (value);
  377.                 break;
  378.             case F_VECTOR:
  379.                 sscanf (value, "%f %f %f", &vec[0], &vec[1], &vec[2]);
  380.                 ((float *)(b+f->ofs))[0] = vec[0];
  381.                 ((float *)(b+f->ofs))[1] = vec[1];
  382.                 ((float *)(b+f->ofs))[2] = vec[2];
  383.                 break;
  384.             case F_INT:
  385.                 *(int *)(b+f->ofs) = atoi(value);
  386.                 break;
  387.             case F_FLOAT:
  388.                 *(float *)(b+f->ofs) = atof(value);
  389.                 break;
  390.             case F_ANGLEHACK:
  391.                 v = atof(value);
  392.                 ((float *)(b+f->ofs))[0] = 0;
  393.                 ((float *)(b+f->ofs))[1] = v;
  394.                 ((float *)(b+f->ofs))[2] = 0;
  395.                 break;
  396.             case F_IGNORE:
  397.                 break;
  398.             }
  399.             return;
  400.         }
  401.     }
  402.     gi.dprintf ("%s is not a field\n", key);
  403. }
  404.  
  405. /*
  406. ====================
  407. ED_ParseEdict
  408.  
  409. Parses an edict out of the given string, returning the new position
  410. ed should be a properly initialized empty edict.
  411. ====================
  412. */
  413. char *ED_ParseEdict (char *data, edict_t *ent)
  414. {
  415.     qboolean    init;
  416.     char        keyname[256];
  417.     char        *com_token;
  418.  
  419.     init = false;
  420.     memset (&st, 0, sizeof(st));
  421.  
  422. // go through all the dictionary pairs
  423.     while (1)
  424.     {    
  425.     // parse key
  426.         com_token = COM_Parse (&data);
  427.         if (com_token[0] == '}')
  428.             break;
  429.         if (!data)
  430.             gi.error ("ED_ParseEntity: EOF without closing brace");
  431.  
  432.         strncpy (keyname, com_token, sizeof(keyname)-1);
  433.         
  434.     // parse value    
  435.         com_token = COM_Parse (&data);
  436.         if (!data)
  437.             gi.error ("ED_ParseEntity: EOF without closing brace");
  438.  
  439.         if (com_token[0] == '}')
  440.             gi.error ("ED_ParseEntity: closing brace without data");
  441.  
  442.         init = true;    
  443.  
  444.     // keynames with a leading underscore are used for utility comments,
  445.     // and are immediately discarded by quake
  446.         if (keyname[0] == '_')
  447.             continue;
  448.  
  449.         ED_ParseField (keyname, com_token, ent);
  450.     }
  451.  
  452.     if (!init)
  453.         memset (ent, 0, sizeof(*ent));
  454.  
  455.     return data;
  456. }
  457.  
  458.  
  459. /*
  460. ================
  461. G_FindTeams
  462.  
  463. Chain together all entities with a matching team field.
  464.  
  465. All but the first will have the FL_TEAMSLAVE flag set.
  466. All but the last will have the teamchain field set to the next one
  467. ================
  468. */
  469. void G_FindTeams (void)
  470. {
  471.     edict_t    *e, *e2, *chain;
  472.     int        i, j;
  473.     int        c, c2;
  474.  
  475.     c = 0;
  476.     c2 = 0;
  477.     for (i=1, e=g_edicts+i ; i < globals.num_edicts ; i++,e++)
  478.     {
  479.         if (!e->inuse)
  480.             continue;
  481.         if (!e->team)
  482.             continue;
  483.         if (e->flags & FL_TEAMSLAVE)
  484.             continue;
  485.         chain = e;
  486.         e->teammaster = e;
  487.         c++;
  488.         c2++;
  489.         for (j=i+1, e2=e+1 ; j < globals.num_edicts ; j++,e2++)
  490.         {
  491.             if (!e2->inuse)
  492.                 continue;
  493.             if (!e2->team)
  494.                 continue;
  495.             if (e2->flags & FL_TEAMSLAVE)
  496.                 continue;
  497.             if (!strcmp(e->team, e2->team))
  498.             {
  499.                 c2++;
  500.                 chain->teamchain = e2;
  501.                 e2->teammaster = e;
  502.                 chain = e2;
  503.                 e2->flags |= FL_TEAMSLAVE;
  504.             }
  505.         }
  506.     }
  507.  
  508.     gi.dprintf ("%i teams with %i entities\n", c, c2);
  509. }
  510.  
  511. /*
  512. ==============
  513. SpawnEntities
  514.  
  515. Creates a server's entity / program execution context by
  516. parsing textual entity definitions out of an ent file.
  517. ==============
  518. */
  519. void SpawnEntities (char *mapname, char *entities, char *spawnpoint)
  520. {
  521.     edict_t        *ent;
  522.     int            inhibit;
  523.     char        *com_token;
  524.     int            i;
  525.     float        skill_level;
  526.  
  527.     skill_level = floor (skill->value);
  528.     if (skill_level < 0)
  529.         skill_level = 0;
  530.     if (skill_level > 3)
  531.         skill_level = 3;
  532.     if (skill->value != skill_level)
  533.         gi.cvar_forceset("skill", va("%f", skill_level));
  534.  
  535.     SaveClientData ();
  536.  
  537.     gi.FreeTags (TAG_LEVEL);
  538.  
  539.     memset (&level, 0, sizeof(level));
  540.     memset (g_edicts, 0, game.maxentities * sizeof (g_edicts[0]));
  541.  
  542.     strncpy (level.mapname, mapname, sizeof(level.mapname)-1);
  543.     strncpy (game.spawnpoint, spawnpoint, sizeof(game.spawnpoint)-1);
  544.  
  545.     // set client fields on player ents
  546.     for (i=0 ; i<game.maxclients ; i++)
  547.         g_edicts[i+1].client = game.clients + i;
  548.  
  549.     ent = NULL;
  550.     inhibit = 0;
  551.  
  552. // parse ents
  553.     while (1)
  554.     {
  555.         // parse the opening brace    
  556.         com_token = COM_Parse (&entities);
  557.         if (!entities)
  558.             break;
  559.         if (com_token[0] != '{')
  560.             gi.error ("ED_LoadFromFile: found %s when expecting {",com_token);
  561.  
  562.         if (!ent)
  563.             ent = g_edicts;
  564.         else
  565.             ent = G_Spawn ();
  566.         entities = ED_ParseEdict (entities, ent);
  567.  
  568.         // yet another map hack
  569.         if (!stricmp(level.mapname, "command") && !stricmp(ent->classname, "trigger_once") && !stricmp(ent->model, "*27"))
  570.             ent->spawnflags &= ~SPAWNFLAG_NOT_HARD;
  571.  
  572.         // remove things (except the world) from different skill levels or deathmatch
  573.         if (ent != g_edicts)
  574.         {
  575.             if (deathmatch->value)
  576.             {
  577.                 if ( ent->spawnflags & SPAWNFLAG_NOT_DEATHMATCH )
  578.                 {
  579.                     G_FreeEdict (ent);    
  580.                     inhibit++;
  581.                     continue;
  582.                 }
  583.             }
  584.             else
  585.             {
  586.                 if ( /* ((coop->value) && (ent->spawnflags & SPAWNFLAG_NOT_COOP)) || */
  587.                     ((skill->value == 0) && (ent->spawnflags & SPAWNFLAG_NOT_EASY)) ||
  588.                     ((skill->value == 1) && (ent->spawnflags & SPAWNFLAG_NOT_MEDIUM)) ||
  589.                     (((skill->value == 2) || (skill->value == 3)) && (ent->spawnflags & SPAWNFLAG_NOT_HARD))
  590.                     )
  591.                     {
  592.                         G_FreeEdict (ent);    
  593.                         inhibit++;
  594.                         continue;
  595.                     }
  596.             }
  597.  
  598.             ent->spawnflags &= ~(SPAWNFLAG_NOT_EASY|SPAWNFLAG_NOT_MEDIUM|SPAWNFLAG_NOT_HARD|SPAWNFLAG_NOT_COOP|SPAWNFLAG_NOT_DEATHMATCH);
  599.         }
  600.  
  601.         ED_CallSpawn (ent);
  602.     }    
  603.  
  604.     gi.dprintf ("%i entities inhibited\n", inhibit);
  605.  
  606.     G_FindTeams ();
  607.  
  608.     PlayerTrail_Init ();
  609. }
  610.  
  611.  
  612. //===================================================================
  613.  
  614. #if 0
  615.     // cursor positioning
  616.     xl <value>
  617.     xr <value>
  618.     yb <value>
  619.     yt <value>
  620.     xv <value>
  621.     yv <value>
  622.  
  623.     // drawing
  624.     statpic <name>
  625.     pic <stat>
  626.     num <fieldwidth> <stat>
  627.     string <stat>
  628.  
  629.     // control
  630.     if <stat>
  631.     ifeq <stat> <value>
  632.     ifbit <stat> <value>
  633.     endif
  634.  
  635. #endif
  636.  
  637. char *single_statusbar = 
  638.  
  639. //backround
  640. "yb -42 "
  641. "xl     0 "
  642. "pic 0 "
  643.  
  644. // health
  645. "yb    -32 "
  646. "xl    34 "
  647. "hnum "
  648.  
  649. // ammo
  650. "if 2 "
  651. "    xl    114 "
  652. "   yb  -32 "
  653. "    anum "
  654. "    xl    164 "
  655. "    pic 2 "
  656. "endif "
  657.  
  658. // armor
  659. "if 4 "
  660. "    xl    189 "
  661. "   yb  -32 "
  662. "    rnum "
  663. "    xl    239 "
  664. "    pic 4 "
  665. "endif "
  666.  
  667. // selected item
  668. "if 6 "
  669. "    xv    296 "
  670. "   yb  -56"
  671. "    pic 6 "
  672. "endif "
  673.  
  674. "yb    -50 "
  675.  
  676. // picked up item
  677. "if 7 "
  678. "    xl    99 "
  679. "    yb    -42 "
  680. "    stat_string 8 "
  681. "    yb    -32 "
  682. "endif "
  683.  
  684. // timer
  685. "if 9 "
  686. "    xv    262 "
  687. "   yb  -32 "
  688. "    num    2    10 "
  689. "    xv    296 "
  690. "   yb  -56 "
  691. "    pic    9 "
  692. "endif "
  693.  
  694. //  help / weapon icon 
  695. "if 11 "
  696. "    xl    -11 "
  697. "    pic    11 "
  698. "endif "
  699. ;
  700.  
  701. char *dm_statusbar =
  702. //backround
  703. "yb -42 "
  704. "xl     0 "
  705. "pic 0 "
  706.  
  707. // health
  708. "yb    -32 "
  709. "xl    34 "
  710. "hnum "
  711.  
  712. // ammo
  713. "if 2 "
  714. "    xl    114 "
  715. "   yb  -32 "
  716. "    anum "
  717. "    xl    164 "
  718. "    pic 2 "
  719. "endif "
  720.  
  721. // armor
  722. "if 4 "
  723. "    xl    189 "
  724. "   yb  -32 "
  725. "    rnum "
  726. "    xl    239 "
  727. "    pic 4 "
  728. "endif "
  729.  
  730. // selected item
  731. "if 6 "
  732. "    xv    296 "
  733. "   yb  -56"
  734. "    pic 6 "
  735. "endif "
  736.  
  737. "yb    -50 "
  738.  
  739. // picked up item
  740. "if 7 "
  741. "    xl    99 "
  742. "    yb    -42 "
  743. "    stat_string 8 "
  744. "    yb    -32 "
  745. "endif "
  746.  
  747. // timer
  748. "if 9 "
  749. "    xv    262 "
  750. "   yb  -32 "
  751. "    num    2    10 "
  752. "    xv    296 "
  753. "   yb  -56 "
  754. "    pic    9 "
  755. "endif "
  756.  
  757. //  help / weapon icon 
  758. "if 11 "
  759. "    xl    -11 "
  760. "    pic    11 "
  761. "endif "
  762.  
  763. //  frags
  764. "xr    -50 "
  765. "yt 2 "
  766. "num 3 14"
  767. ;
  768.  
  769.  
  770. /*QUAKED worldspawn (0 0 0) ?
  771.  
  772. Only used for the world.
  773. "sky"    environment map name
  774. "skyaxis"    vector axis for rotating sky
  775. "skyrotate"    speed of rotation in degrees/second
  776. "sounds"    music cd track number
  777. "gravity"    800 is default gravity
  778. "message"    text to print at user logon
  779. */
  780. void SP_worldspawn (edict_t *ent)
  781. {
  782.     ent->movetype = MOVETYPE_PUSH;
  783.     ent->solid = SOLID_BSP;
  784.     ent->inuse = true;            // since the world doesn't use G_Spawn()
  785.     ent->s.modelindex = 1;        // world model is always index 1
  786.  
  787.     //---------------
  788.  
  789.     // reserve some spots for dead player bodies for coop / deathmatch
  790.     InitBodyQue ();
  791.  
  792.     // set configstrings for items
  793.     SetItemNames ();
  794.  
  795.     if (st.nextmap)
  796.         strcpy (level.nextmap, st.nextmap);
  797.  
  798.     // make some data visible to the server
  799.  
  800.     if (ent->message && ent->message[0])
  801.     {
  802.         gi.configstring (CS_NAME, ent->message);
  803.         strncpy (level.level_name, ent->message, sizeof(level.level_name));
  804.     }
  805.     else
  806.         strncpy (level.level_name, level.mapname, sizeof(level.level_name));
  807.  
  808.     if (st.sky && st.sky[0])
  809.         gi.configstring (CS_SKY, st.sky);
  810.     else
  811.         gi.configstring (CS_SKY, "unit1_");
  812.  
  813.     gi.configstring (CS_SKYROTATE, va("%f", st.skyrotate) );
  814.  
  815.     gi.configstring (CS_SKYAXIS, va("%f %f %f",
  816.         st.skyaxis[0], st.skyaxis[1], st.skyaxis[2]) );
  817.  
  818.     gi.configstring (CS_CDTRACK, va("%i", ent->sounds) );
  819.  
  820.     gi.configstring (CS_MAXCLIENTS, va("%i", (int)(maxclients->value) ) );
  821.  
  822.     // status bar program
  823.     if (deathmatch->value)
  824.         gi.configstring (CS_STATUSBAR, dm_statusbar);
  825.     else
  826.         gi.configstring (CS_STATUSBAR, single_statusbar);
  827.  
  828.     //---------------
  829.  
  830.  
  831.     // help icon for statusbar
  832.     gi.imageindex ("i_help");
  833.     level.pic_health = gi.imageindex ("i_health");
  834.     gi.imageindex ("help");
  835.     gi.imageindex ("field_3");
  836.  
  837.     if (!st.gravity)
  838.         gi.cvar_set("sv_gravity", "800");
  839.     else
  840.         gi.cvar_set("sv_gravity", st.gravity);
  841.  
  842.     snd_fry = gi.soundindex ("player/fry.wav");    // standing in lava / slime
  843.  
  844.     PrecacheItem (FindItem ("Blaster"));
  845.  
  846.     gi.soundindex ("player/lava1.wav");
  847.     gi.soundindex ("player/lava2.wav");
  848.  
  849.     gi.soundindex ("misc/pc_up.wav");
  850.     gi.soundindex ("misc/talk1.wav");
  851.  
  852.     gi.soundindex ("misc/udeath.wav");
  853.  
  854.     // gibs
  855.     gi.soundindex ("items/respawn1.wav");
  856.  
  857.     // sexed sounds
  858.     gi.soundindex ("*death1.wav");
  859.     gi.soundindex ("*death2.wav");
  860.     gi.soundindex ("*death3.wav");
  861.     gi.soundindex ("*death4.wav");
  862.     gi.soundindex ("*fall1.wav");
  863.     gi.soundindex ("*fall2.wav");    
  864.     gi.soundindex ("*gurp1.wav");        // drowning damage
  865.     gi.soundindex ("*gurp2.wav");    
  866.     gi.soundindex ("*jump1.wav");        // player jump
  867.     gi.soundindex ("*pain25_1.wav");
  868.     gi.soundindex ("*pain25_2.wav");
  869.     gi.soundindex ("*pain50_1.wav");
  870.     gi.soundindex ("*pain50_2.wav");
  871.     gi.soundindex ("*pain75_1.wav");
  872.     gi.soundindex ("*pain75_2.wav");
  873.     gi.soundindex ("*pain100_1.wav");
  874.     gi.soundindex ("*pain100_2.wav");
  875.  
  876.     //-------------------
  877.  
  878.     gi.soundindex ("player/gasp1.wav");        // gasping for air
  879.     gi.soundindex ("player/gasp2.wav");        // head breaking surface, not gasping
  880.  
  881.     gi.soundindex ("player/watr_in.wav");    // feet hitting water
  882.     gi.soundindex ("player/watr_out.wav");    // feet leaving water
  883.  
  884.     gi.soundindex ("player/watr_un.wav");    // head going underwater
  885.     
  886.     gi.soundindex ("player/u_breath1.wav");
  887.     gi.soundindex ("player/u_breath2.wav");
  888.  
  889.     gi.soundindex ("items/pkup.wav");        // bonus item pickup
  890.     gi.soundindex ("world/land.wav");        // landing thud
  891.     gi.soundindex ("misc/h2ohit1.wav");        // landing splash
  892.  
  893.     gi.soundindex ("items/damage.wav");
  894.     gi.soundindex ("items/protect.wav");
  895.     gi.soundindex ("items/protect4.wav");
  896.     gi.soundindex ("weapons/noammo.wav");
  897.  
  898.     gi.soundindex ("infantry/inflies1.wav");
  899.  
  900.     sm_meat_index = gi.modelindex ("models/objects/gibs/sm_meat/tris.md2");
  901.     gi.modelindex ("models/objects/gibs/arm/tris.md2");
  902.     gi.modelindex ("models/objects/gibs/bone/tris.md2");
  903.     gi.modelindex ("models/objects/gibs/bone2/tris.md2");
  904.     gi.modelindex ("models/objects/gibs/chest/tris.md2");
  905.     gi.modelindex ("models/objects/gibs/skull/tris.md2");
  906.     gi.modelindex ("models/objects/gibs/head2/tris.md2");
  907.  
  908. //
  909. // Setup light animation tables. 'a' is total darkness, 'z' is doublebright.
  910. //
  911.  
  912.     // 0 normal
  913.     gi.configstring(CS_LIGHTS+0, "m");
  914.     
  915.     // 1 FLICKER (first variety)
  916.     gi.configstring(CS_LIGHTS+1, "mmnmmommommnonmmonqnmmo");
  917.     
  918.     // 2 SLOW STRONG PULSE
  919.     gi.configstring(CS_LIGHTS+2, "abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba");
  920.     
  921.     // 3 CANDLE (first variety)
  922.     gi.configstring(CS_LIGHTS+3, "mmmmmaaaaammmmmaaaaaabcdefgabcdefg");
  923.     
  924.     // 4 FAST STROBE
  925.     gi.configstring(CS_LIGHTS+4, "mamamamamama");
  926.     
  927.     // 5 GENTLE PULSE 1
  928.     gi.configstring(CS_LIGHTS+5,"jklmnopqrstuvwxyzyxwvutsrqponmlkj");
  929.     
  930.     // 6 FLICKER (second variety)
  931.     gi.configstring(CS_LIGHTS+6, "nmonqnmomnmomomno");
  932.     
  933.     // 7 CANDLE (second variety)
  934.     gi.configstring(CS_LIGHTS+7, "mmmaaaabcdefgmmmmaaaammmaamm");
  935.     
  936.     // 8 CANDLE (third variety)
  937.     gi.configstring(CS_LIGHTS+8, "mmmaaammmaaammmabcdefaaaammmmabcdefmmmaaaa");
  938.     
  939.     // 9 SLOW STROBE (fourth variety)
  940.     gi.configstring(CS_LIGHTS+9, "aaaaaaaazzzzzzzz");
  941.     
  942.     // 10 FLUORESCENT FLICKER
  943.     gi.configstring(CS_LIGHTS+10, "mmamammmmammamamaaamammma");
  944.  
  945.     // 11 SLOW PULSE NOT FADE TO BLACK
  946.     gi.configstring(CS_LIGHTS+11, "abcdefghijklmnopqrrqponmlkjihgfedcba");
  947.     
  948.     // styles 32-62 are assigned by the light program for switchable lights
  949.  
  950.     // 63 testing
  951.     gi.configstring(CS_LIGHTS+63, "a");
  952. }
  953.  
  954.